package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

go run hello.go

// यह एक सिंगल-लाइन कमेंट है
fmt.Println("Hello, World!")

/*
यह एक मल्टी-लाइन कमेंट है
जो कई लाइनों में फैला हुआ है
*/

// एक्सप्लिसिट टाइप डिक्लेरेशन
var name string = "John"
var age int = 25

// टाइप इन्फेरेंस
name := "John"
age := 25

// मल्टीपल वेरिएबल डिक्लेरेशन
var x, y int = 10, 20
x, y := 10, 20

// इंटीजर टाइप्स
var age int = 25
var smallNumber int8 = 127
var largeNumber int64 = 9223372036854775807

// फ्लोट टाइप्स
var temperature float32 = 36.5
var pi float64 = 3.14159265359

// कॉम्प्लेक्स नंबर्स
var complexNum complex64 = 3 + 4i

// स्ट्रिंग डिक्लेरेशन
var greeting string = "Hello, Go!"
name := "Alice"

// स्ट्रिंग ऑपरेशन्स
fmt.Println(len(greeting))        // स्ट्रिंग लंबाई
fmt.Println(greeting[0])          // पहला कैरेक्टर एक्सेस करें (बाइट)
fmt.Println(greeting[0:5])        // स्ट्रिंग स्लाइसिंग
fmt.Println(strings.ToUpper(name)) // अपरकेस में कन्वर्ट करें

var isActive bool = true
var isComplete bool = false

// बूलियन ऑपरेशन्स
result1 := true && false  // false
result2 := true || false  // true
result3 := !true          // false

const Pi = 3.14159
const MaxUsers = 1000

// मल्टीपल कॉन्स्टेंट्स
const (
    StatusOK = 200
    StatusNotFound = 404
    StatusError = 500
)

// टाइप्ड कॉन्स्टेंट्स
const Version string = "1.0.0"

// ऐरे डिक्लेरेशन
var numbers [5]int = [5]int{1, 2, 3, 4, 5}
names := [3]string{"Alice", "Bob", "Charlie"}

// एलिमेंट्स एक्सेस करना
fmt.Println(numbers[0])  // 1
numbers[0] = 10         // एलिमेंट मॉडिफाई करें

// ऐरे लंबाई
fmt.Println(len(numbers)) // 5

// स्लाइस डिक्लेरेशन
numbers := []int{1, 2, 3, 4, 5}
var emptySlice []int

// ऐरेज़ से स्लाइसेज़ बनाना
arr := [5]int{1, 2, 3, 4, 5}
slice := arr[1:4]  // [2, 3, 4]

// स्लाइस ऑपरेशन्स
numbers = append(numbers, 6)      // एलिमेंट जोड़ें
numbers = append(numbers, 7, 8, 9) // मल्टीपल एलिमेंट्स जोड़ें

// स्लाइस कैपेसिटी और लंबाई
fmt.Println(len(numbers)) // लंबाई: 9
fmt.Println(cap(numbers)) // कैपेसिटी: 10 (भिन्न हो सकती है)

// मैप डिक्लेरेशन
student := map[string]interface{}{
    "name": "John",
    "age":  20,
    "major": "Computer Science",
}

// अल्टरनेटिव डिक्लेरेशन
var scores map[string]int = make(map[string]int)
scores["math"] = 95
scores["science"] = 88

// एक्सेसिंग और मॉडिफाइंग
fmt.Println(student["name"])
student["age"] = 21
student["gpa"] = 3.8

// सेफ एक्सेस
if phone, exists := student["phone"]; exists {
    fmt.Println(phone)
} else {
    fmt.Println("Phone not provided")
}

// मैप पर इटरेट करना
for key, value := range student {
    fmt.Printf("%s: %v\n", key, value)
}

// स्ट्रक्ट डेफिनिशन
type Person struct {
    Name string
    Age  int
    City string
}

// स्ट्रक्ट इंस्टेंसेज़ बनाना
person1 := Person{"Alice", 25, "New York"}
person2 := Person{
    Name: "Bob",
    Age:  30,
    City: "London",
}

// फील्ड्स एक्सेस करना
fmt.Println(person1.Name)
person1.Age = 26

a, b := 10, 3

fmt.Printf("Addition: %d\n", a + b)      // 13
fmt.Printf("Subtraction: %d\n", a - b)   // 7
fmt.Printf("Multiplication: %d\n", a * b)  // 30
fmt.Printf("Division: %d\n", a / b)      // 3
fmt.Printf("Modulus: %d\n", a % b)      // 1

x, y := 5, 10

fmt.Printf("Equal: %t\n", x == y)     // false
fmt.Printf("Not equal: %t\n", x != y) // true
fmt.Printf("Greater than: %t\n", x > y)  // false
fmt.Printf("Less than: %t\n", x < y)  // true

a, b := true, false

fmt.Printf("AND operation: %t\n", a && b)  // false
fmt.Printf("OR operation: %t\n", a || b)    // true
fmt.Printf("NOT operation: %t\n", !a)    // false

age := 20
if age >= 18 {
    fmt.Println("Adult")
} else if age >= 13 {
    fmt.Println("Teen")
} else {
    fmt.Println("Child")
}

// शॉर्ट स्टेटमेंट के साथ if
if score := 85; score >= 90 {
    fmt.Println("Grade: A")
} else if score >= 80 {
    fmt.Println("Grade: B")
} else {
    fmt.Println("Grade: C")
}

// बेसिक for लूप
for i := 0; i < 5; i++ {
    fmt.Println(i)
}

// व्हाइल-स्टाइल लूप
count := 0
for count < 5 {
    fmt.Println(count)
    count++
}

// इनफिनिट लूप
for {
    fmt.Println("This will run forever")
    break // बाहर निकलने के लिए break का उपयोग करें
}

// रेंज लूप (स्लाइसेज़, ऐरेज़, मैप्स के लिए)
fruits := []string{"apple", "banana", "cherry"}
for index, fruit := range fruits {
    fmt.Printf("%d: %s\n", index, fruit)
}

day := "Monday"
switch day {
case "Monday":
    fmt.Println("Start of the week")
case "Friday":
    fmt.Println("Weekend is near")
case "Saturday", "Sunday":
    fmt.Println("Weekend!")
default:
    fmt.Println("Regular day")
}

// एक्सप्रेशन के बिना switch
score := 85
switch {
case score >= 90:
    fmt.Println("Grade: A")
case score >= 80:
    fmt.Println("Grade: B")
case score >= 70:
    fmt.Println("Grade: C")
default:
    fmt.Println("Grade: F")
}

func greet(name string) string {
    return "Hello, " + name + "!"
}

// फंक्शन को कॉल करना
message := greet("John")
fmt.Println(message)

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("cannot divide by zero")
    }
    return a / b, nil
}

// मल्टीपल रिटर्न वैल्यूज का उपयोग करना
result, err := divide(10, 2)
if err != nil {
    fmt.Println("Error:", err)
} else {
    fmt.Println("Result:", result)
}

func calculateRectangle(width, height float64) (area float64, perimeter float64) {
    area = width * height
    perimeter = 2 * (width + height)
    return // नेक्ड रिटर्न
}

area, perimeter := calculateRectangle(5, 3)
fmt.Printf("Area: %.2f, Perimeter: %.2f\n", area, perimeter)

func sum(numbers ...int) int {
    total := 0
    for _, num := range numbers {
        total += num
    }
    return total
}

fmt.Println(sum(1, 2, 3, 4))  // 10
fmt.Println(sum(5, 10, 15))   // 30

func modifyValue(x *int) {
    *x = *x * 2
}

func main() {
    value := 10
    fmt.Println("Before:", value) // 10

    modifyValue(&value)
    fmt.Println("After:", value)  // 20
}

type Rectangle struct {
    Width  float64
    Height float64
}

// वैल्यू रिसीवर के साथ मेथड
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

// पॉइंटर रिसीवर के साथ मेथड
func (r *Rectangle) Scale(factor float64) {
    r.Width *= factor
    r.Height *= factor
}

rect := Rectangle{Width: 5, Height: 3}
fmt.Println("Area:", rect.Area()) // 15

rect.Scale(2)
fmt.Println("Scaled Area:", rect.Area()) // 60

type Shape interface {
    Area() float64
    Perimeter() float64
}

type Circle struct {
    Radius float64
}

func (c Circle) Area() float64 {
    return 3.14159 * c.Radius * c.Radius
}

func (c Circle) Perimeter() float64 {
    return 2 * 3.14159 * c.Radius
}

func printShapeInfo(s Shape) {
    fmt.Printf("Area: %.2f, Perimeter: %.2f\n", s.Area(), s.Perimeter())
}

circle := Circle{Radius: 5}
printShapeInfo(circle)

func readFile(filename string) (string, error) {
    data, err := os.ReadFile(filename)
    if err != nil {
        return "", fmt.Errorf("failed to read file %s: %w", filename, err)
    }
    return string(data), nil
}

content, err := readFile("example.txt")
if err != nil {
    fmt.Println("Error:", err)
    return
}
fmt.Println("Content:", content)

func worker(id int) {
    for i := 0; i < 3; i++ {
        fmt.Printf("Worker %d: %d\n", id, i)
        time.Sleep(time.Millisecond * 100)
    }
}

func main() {
    // मल्टीपल गोरूटीन्स शुरू करें
    for i := 1; i <= 3; i++ {
        go worker(i)
    }

    // गोरूटीन्स के पूरा होने का इंतजार करें
    time.Sleep(time.Second)
    fmt.Println("All workers completed")
}

func producer(ch chan<- int) {
    for i := 0; i < 5; i++ {
        ch <- i // चैनल को वैल्यू भेजें
        time.Sleep(time.Millisecond * 100)
    }
    close(ch) // काम पूरा होने पर चैनल बंद करें
}

func consumer(ch <-chan int) {
    for value := range ch {
        fmt.Println("Received:", value)
    }
}

func main() {
    ch := make(chan int, 3) // बफर्ड चैनल

    go producer(ch)
    consumer(ch)

    fmt.Println("Channel communication completed")
}

// फाइल्स पढ़ना
data, err := os.ReadFile("example.txt")
if err != nil {
    fmt.Println("Error reading file:", err)
    return
}
fmt.Println("File content:", string(data))

// फाइल्स लिखना
content := "Hello, Go!\n"
err = os.WriteFile("output.txt", []byte(content), 0644)
if err != nil {
    fmt.Println("Error writing file:", err)
    return
}
fmt.Println("File written successfully")

// स्टैंडर्ड लाइब्रेरी पैकेजेस इम्पोर्ट करना
import (
    "fmt"
    "math"
    "strings"
)

func main() {
    fmt.Println(math.Sqrt(16))        // 4
    fmt.Println(strings.ToUpper("go")) // GO
}

// math_test.go फाइल में
package main

import "testing"

func TestAdd(t *testing.T) {
    result := add(2, 3)
    expected := 5
    if result != expected {
        t.Errorf("add(2, 3) = %d; want %d", result, expected)
    }
}

func add(a, b int) int {
    return a + b
}